package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.Item;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.List;

@Service
public class ItemCatServiceImpl implements ItemCatService {
    @Autowired
    private ItemCatMapper itemCatMapper;

    /**
     * 思路:
     *      1.判断map集合中是否存在key
     *      2.如果key 不存在 准备一个新list集合,将自己作为第一个元素添加
     *      3.如果key 存 在  获取list集合,将自己追加.
     * Map<k,v> k=parent_id ,v=当前父级的子级数据
     * @return
     */
    public Map<Integer, List<ItemCat>> getMap() {
        Map<Integer, List<ItemCat>> map = new HashMap<>();
        //查询所有商品分类信息 获取数据
        List<ItemCat> list = itemCatMapper.selectList(null);
        for (ItemCat itemCat : list) {//遍历数据得到对象
            int key = itemCat.getParentId();//key值=对象的父级Id
            if (map.containsKey(key)) {//true 追加数据
                map.get(key).add(itemCat);
            } else {//false 准备新集合 添加数据
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);
                map.put(key, childrenList);
            }
        }
        return map;
    }

    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //获取getMap方法 获取数据信息
        Map<Integer, List<ItemCat>> map = getMap();
        if (level == 1) {//level=1,key为0
            return map.get(0);
        }
        if (level == 2) {//获取二级方法
            return getTwoList(map);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("运行时间：" + (endTime - startTime) + "毫秒");
        List<ItemCat> list = getThereList(map);
        return list;
    }

    //1-2-3
    private List<ItemCat> getThereList(Map<Integer, List<ItemCat>> map) {
        //获取一级数据
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat : oneList) {//遍历一级数据获取一级对象
            /**因为在二级中，已经把二级数据封装到一级对象中，所以可以通过一级对象的children来获取二级数据*/
            List<ItemCat> twoList = oneItemCat.getChildren();
            if (twoList == null) {//若二级数据为空，continue跳过本次循环，进入下一次循环
                continue;
            }
            for (ItemCat twoItemCat : twoList) {//有二级数据的话，遍历二级数据获取二级对象
                int key = twoItemCat.getId();//三级数据的key=二级对象的id
                List<ItemCat> thereList = map.get(key);//获取三级数据
                twoItemCat.setChildren(thereList);//把三级数据封装到二级对象中
            }
        }
        return oneList;
    }

    //1-2
    private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
        //获取一级数据
        List<ItemCat> oneList = map.get(0);
        for (ItemCat oneItemCat : oneList) {//遍历一级数据得到一级对象
            int key = oneItemCat.getId();//二级数据的key即一级数据的Id
            List<ItemCat> twoList = map.get(key);//获取二级数据
            oneItemCat.setChildren(twoList);//将二级数据封装到一级对象中
        }
        return oneList;//返回一级数据
    }

    /**
     * 删除的思路:
     *      1.判断是否为3级  如果是直接删除
     *      2.判断是否为2级  如果是2级,先删除三级,再删除2级
     *      3.如果是1级,先查询2级,再删除3级/2级/1级
     * @param itemCat
     */
    @Override//商品分类删除
    public void deleteItemCat(ItemCat itemCat) {
        if (itemCat.getLevel() == 3) {
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        if (itemCat.getLevel() == 2) {
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        //执行到这里 只剩下一级菜单
        //1.应该先查询二级id
        int oneId = itemCat.getId();//获取一级id
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", oneId);
        List twoIdList = itemCatMapper.selectObjs(queryWrapper);//获取二级所有id，通过父级id=oneId
        if (twoIdList.size() == 0 || twoIdList == null) {
            //如果没有二级数据，则直接删除一级信息
            itemCatMapper.deleteById(oneId);
        } else {
            /**
             * 如果有二级数据，删除顺序 3/2/1
             * SQL: delete from item_cat where parent_id in(xx,xx,xx)
             *      or id in(xxx,xxx,xx)
             *      or id in(oneId)
             * */
            queryWrapper.clear();//清空条件
            queryWrapper.in("parent_id", twoIdList)//重构条件
                    .or()
                    .in("id", twoIdList)
                    .or()
                    .eq("id", oneId);
            itemCatMapper.delete(queryWrapper);
        }
    }

    @Override//修改状态
    public void updateStatus(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);

    }

    @Override//新增
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);//新增记得加状态为true
        itemCatMapper.insert(itemCat);
    }

    @Override//商品分类修改
    public void updateItemCat(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }

    /**
     * 只查询一级菜单  parent_id=0 或者 level=1
     * 查询二级菜单信息 parent_id = 一级ID
     * 查询三级菜单信息 parent_id = 二级ID
     * 思考: 如何优化代码   要求查询时间最好 控制在20ms+-
     * @param level
     * @return
     */
   /* @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
        for (ItemCat oneItemCat : oneList){
            //获取一级对象的ID
            int oneId = oneItemCat.getId();
            //清空多余的条件
            queryWrapper.clear();
            //查询二级数据
            queryWrapper.eq("parent_id",oneId);
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            //获取3级菜单信息
            for(ItemCat twoItemCat : twoList){
                int twoId = twoItemCat.getId();
                queryWrapper.clear();
                queryWrapper.eq("parent_id",twoId);
                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
                //将三级数据封装到二级对象中
                twoItemCat.setChildren(threeList);
            }
            //将二级封装到一级对象中
            oneItemCat.setChildren(twoList);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("业务调用耗时:"+(endTime - startTime)+"毫秒");
        return oneList;
    }*/


}
